
#ifndef NODE_H_
#define NODE_H_

#include <string>
#include "../list/list.hpp"
#include "edge.hpp"
#include "nodeIterator.hpp"

/**
 * Class Node: representa los nodos del grafo
 */
class Node {
private:
		std::string id;
		List<Edge> 	edgeList;
		int 		positionX;
		int 		positionY;
		Edge  		*minimunPathEdge;
		float  		temporalWeight;
		bool		belongToMP;
public:
	/**
	 * Constructor por defecto de la clase Node.
	 */
	Node();

	/**
     * Constructor parametrizado de la clase Node.
     */
	Node(std::string id, int positionX, int positionY);

	/**
	 * Metodo getter del id del nodo.
	 * @return Retorna el id del nodo.
	 */
	std::string getId();

	/**
	 * Metodo getter de la estructura de aristas del nodo.
	 * @return Retorna la estructura de aristas del nodo.
	 */
	List<Edge>* getEdgeList();

	/**
	 * Metodo getter de la posicion X del nodo.
	 * @return Retorna la posicion X del nodo.
	 */
	int getPositionX();

	/**
	 * Metodo getter de la posicion Y del nodo.
	 * @return Retorna la posicion Y del nodo.
	 */
	int getPositionY();

	/**
	 * Metodo setter del id del nodo.
	 * @param id de clase std::string.
	 */
	void setId(std::string id);

	/**
	 * Metodo setter de la estructura de aristas del nodo.
	 * @param edgeList de clase List<Edge>.
	 */
	void setEdgeList(List<Edge> edgeList);

	/**
	 * Metodo setter de la posicion X del nodo.
	 * @param positionX de tipo float.
	 */
	void setPositionX(int positionX);

	/**
	 * Metodo setter de la posicion Y del nodo.
	 * @param positionY de tipo float.
	 */
	void setPositionY(int positionY);

	/**
	 * Agrega una arista a la estructura de aristas del nodo.
	 * @param edge de clase Edge*.
	 */
    void addEgde(Edge *edge);

    /**
     * Chequea si el nodo pasado por parametro tiene
     * la misma posicion que el nodo "this".
     * @param newNode clase Node*.
     * @return true en caso de tener la misma posicion.
     * @return false en caso contrario.
     */
    bool hasSamePosition(Node *newNode);

    /**
     * Operador asignacion.
     */
	Node &operator=(Node &original);

	/**
	 * Operador comparacion.
	 */
    int operator==(Node &original) const;

    /**
     * Operador comparacion por diferencia.
     */
    int operator!=(Node &original) const;

    /**
     * Operador menor.
     */
    int operator<(Node &original) const;

    /**
     * Operador mayor.
     */
    int operator>(Node &original) const;

    /**
     * Operador menor-igual.
     */
    int operator<=(Node &original) const;

    /**
     * Operador mayor-igual.
     */
    int operator>=(Node &original) const;

    /**
     * TODO
     */
    NodeIterator iterator();

    /**
     * Destructor de la clase Node.
     */
	virtual ~Node();

	/**
	 * Metodo getter de la arista de camino minimo del nodo.
	 * @return Retorna un puntero a la arista de camino minimo del nodo.
	 */
	Edge* getMinimunPathEdge();

	/**
	 * Metodo setter de la arista de camino minimo.
	 * @param mpe de clase Edge*.
	 */
	void setMinimunPathEdge(Edge *mpe);

	/**
	 * Metodo getter del peso temporal de camino minimo del nodo.
	 * @return Retorna el peso temporal de camino minimo del nodo.
	 */
	float getTemporalWeight();

	/**
	 * Metodo setter del peso temporal de camino minimo del nodo.
	 * @param tw de tipo float.
	 */
	void setTemporalWeight(float tw);


	//Devuelve si pertenece al camino minimo
	bool getBelongToMP();

	//Setea si pertenece al camino minimo
	void setBelongToMP();

	//Borrar todo lo refente a la busqueda del MP y a su seteo
	void cleanMPInfo();
};

#endif 
